@bridge-ds/core 0.22.0 → 0.24.0

package/dist/build-requests.d.ts

@@ -8,6 +8,8 @@ export declare const BUILD_REQUEST_LABEL = "bridge-build";
 export declare const SOURCE_FIGMA_LABEL = "source: figma";
 /** A build request waits this many days before it reads as stale. */
 export declare const BUILD_STALE_DAYS = 7;
+/** A request closed as not planned stays in the "All" list this many days after it was closed, then leaves it. */
+export declare const BUILD_DECLINED_DAYS = 7;
 /**
  * What the two images of a build request are called on designer screens (Studio): the component as it is in code
  * now, and the design in Figma. The data keeps its field names, `before` and `after`; the GitHub issue table, read by
@@ -290,6 +292,8 @@ export interface BuildPullLike {
     assignees?: string[] | undefined;
     createdAt?: string | undefined;
     updatedAt?: string | undefined;
+    /** When it was closed (merged or not), when known. */
+    closedAt?: string | null | undefined;
     body?: string | undefined;
     /** Commits on the branch, when known (a branch with only the spec commit is not work in progress). */
     commits?: number | null | undefined;
@@ -384,7 +388,12 @@ export declare function assembleBuildRequests(input: {
 /** The filters of the Being built page. */
 export type BuildFilter = 'all' | 'waiting' | 'in-progress' | 'shipped-this-week';
 export declare const BUILD_FILTER_LABEL: Record<BuildFilter, string>;
-/** Whether a build request shows under a filter. "All" leaves out what was closed as not planned more than a week ago. */
+/** When a build request was closed as not planned, from its timeline, or null. */
+export declare const declinedAt: (v: Pick<BuildRequestView, "status" | "timeline">) => string | null;
+/**
+ * Whether a build request shows under a filter. "All" keeps a request closed as not planned for BUILD_DECLINED_DAYS
+ * after it was closed (one without a close date leaves at once), then leaves it out; shipped requests stay in "All".
+ */
 export declare function matchesBuildFilter(v: Pick<BuildRequestView, 'status' | 'shippedAt' | 'timeline'>, f: BuildFilter, now?: Date | number): boolean;
 /** Build requests still open (not shipped, not closed). */
 export declare const openBuildRequests: <V extends Pick<BuildRequestView, "status">>(views: readonly V[]) => V[];

package/dist/exploration-resume.d.ts

@@ -13,6 +13,24 @@ export declare function explorationStage(x: {
     archived?: boolean | null | undefined;
     files: readonly string[] | null | undefined;
 }): 'not-started' | 'exploring' | 'handed';
+/** The words of a running exploration on its page, and on every row and card that lists it. */
+export declare const EXPLORATION_STAGE_LABEL: {
+    readonly 'not-started': "Not started";
+    readonly exploring: "Exploring";
+    readonly archived: "Archived";
+};
+/**
+ * The one status tag of an exploration wherever it is listed (Changes rows, Home cards, tools): the words its page
+ * shows. Running: "Not started" while the branch only carries Bridge notes, else "Exploring". Archived: "Archived".
+ * After done exploring: where it stands ("Waiting for code", "Being built", "Shipped"). Never a check or a technical
+ * blocker: an exploration's guard check fails by design. `files` undefined (not read yet): null for a running one, so
+ * a row never guesses; null (the read failed): "Exploring", as on the page.
+ */
+export declare function explorationStateLabel(x: {
+    status: ExplorationStatus;
+    archived?: boolean | null | undefined;
+    files?: readonly string[] | null | undefined;
+}): string | null;
 export interface ContinueRef {
     number: number;
     name: string;

package/dist/explorations-github.d.ts

@@ -19,6 +19,8 @@ export interface ExplorationSettings {
     labels?: string[] | undefined;
     /** Started in a product's own repository (productRepoOf): what its draft pull request body says instead of the library's. */
     inProduct?: ExplorationPrContext['inProduct'];
+    /** Wait between label retries, in ms (tests pass 0). */
+    retryMs?: number | undefined;
 }
 /** The first commit message of an exploration branch: the purpose only when one was given. */
 export declare const explorationStartMessage: (e: Pick<Exploration, "name" | "purpose">) => string;
@@ -106,6 +108,11 @@ export interface StartedExploration {
         label: string;
         url: string;
     }[];
+    /**
+     * Labels GitHub refused even after retries (labelExploration). The pull request exists: lists still read it as an
+     * exploration (isUnlabeledExploration) and Studio puts `exploration` back; callers say it in one line.
+     */
+    labelsMissing?: string[];
 }
 /**
  * Starts an exploration: the branch `explore/<slug>` from the base with one commit (the exploration note), a draft
@@ -113,6 +120,12 @@ export interface StartedExploration {
  * install command. Refuses an exploration whose branch already exists.
  */
 export declare function startExplorationOnGitHub(gh: GitHubClient, e: Exploration, s: ExplorationSettings): Promise<StartedExploration>;
+/**
+ * Labels a new exploration: `exploration` on its own first, tried three times (GitHub sometimes refuses a label on a
+ * pull request created a moment ago), then the other labels in one more call. A label that does not exist yet (a
+ * product's) can fail on its own without taking `exploration` with it. Returns the labels still missing.
+ */
+export declare function labelExploration(gh: Pick<GitHubClient, 'addLabels'>, pr: number, extra: readonly string[], retryMs?: number): Promise<string[]>;
 /** Whether Bridge can open an exploration in a product's own repository with this token, and from which branch. */
 export type ProductRepoAccess = {
     ok: true;

package/dist/explorations.d.ts

@@ -71,7 +71,7 @@ export declare function explorationSlugFromBranch(ref: string): string | null;
 /**
  * Which exploration a person or a tool means, wherever it lives. In the design system repository: its number ("12",
  * "#12") or its name ("pill-buttons", "explore/pill-buttons"). In a product's own repository, the product key or the
- * repository goes first: "shop#12", "peterbono/bridge-demo-shop#12", "shop:checkout-flow", or the pull request link.
+ * repository goes first: "admin-app#12", "peterbono/bridge-product-admin#12", "admin-app:checkout-flow", or the pull request link.
  */
 export interface ExplorationRef {
     /** A product key ("shop"), when the reference names one. */
@@ -152,6 +152,21 @@ export interface ExplorationPullLike {
 }
 /** True for a pull request that is or was an exploration: an `explore/*` branch, the label, or the Bridge block. */
 export declare function isExplorationPull(p: ExplorationPullLike): boolean;
+/**
+ * A running exploration whose `exploration` label is missing, because the label call failed when it was started: an
+ * open draft on an `explore/*` branch or with the Bridge block, neither archived nor done exploring. Every list, page
+ * and status treats it as running (explorationStatus, isHeldExploration), and Studio puts the label back for a viewer
+ * who can write. An older promotion also removed the label, but it marked the pull request ready for review: not a draft.
+ */
+export declare function isUnlabeledExploration(p: {
+    state?: string | undefined;
+    draft?: boolean | undefined;
+    labels?: readonly (string | {
+        name?: string;
+    })[] | null | undefined;
+    headRef?: string | null | undefined;
+    body?: string | null | undefined;
+}): boolean;
 /** "Done exploring" was said: the `ready-for-devs` label, or the date in the exploration block. */
 export declare function isHandedOff(p: Pick<ExplorationPullLike, 'labels' | 'body'>): boolean;
 /**
@@ -161,6 +176,27 @@ export declare function isHandedOff(p: Pick<ExplorationPullLike, 'labels' | 'bod
  * done exploring is the older promotion: promoted, open or merged.
  */
 export declare function explorationStatus(p: ExplorationPullLike): ExplorationStatus;
+/**
+ * The pull request is an exploration right now: open with the `exploration` label (archived ones keep it), or a running
+ * exploration whose label is missing (isUnlabeledExploration: an open draft on an `explore/*` branch or with the
+ * Bridge block). Its guard check (EXPLORATION_CHECK) fails by design then, so every check summary leaves that check out
+ * (review-gate summarizeCi `exploration`): Studio, the MCP server and the CLI never read it as a problem. Any other
+ * pull request with that check failing still counts it.
+ */
+export declare function isGuardedExploration(p: {
+    state?: string | undefined;
+    draft?: boolean | undefined;
+    labels?: readonly (string | {
+        name?: string;
+    })[] | null | undefined;
+    headRef?: string | null | undefined;
+    head?: {
+        ref?: string | null | undefined;
+    } | null | undefined;
+    body?: string | null | undefined;
+}): boolean;
+/** True for the guard check of an exploration (EXPLORATION_CHECK), by check run name or status context. */
+export declare const isExplorationCheck: (name: string | null | undefined) => boolean;
 /** True while the label is on: the pull request must not merge (the CI check fails, Studio blocks the merge). */
 export declare const isActiveExploration: (labels: ExplorationPullLike["labels"]) => boolean;
 /** True for an archived exploration: hidden from the default lists, reachable from the Archived filter. */
@@ -177,6 +213,12 @@ export declare function isHeldExploration(p: {
     labels?: readonly (string | {
         name?: string;
     })[] | null | undefined;
+    /** The branch and the body: a running exploration whose label is missing is held too (isUnlabeledExploration). */
+    headRef?: string | null | undefined;
+    head?: {
+        ref?: string | null | undefined;
+    } | null | undefined;
+    body?: string | null | undefined;
 }): boolean;
 /** How a developer takes an exploration: fetch, then check out its branch. */
 export declare const explorationTakeCommands: (branch: string) => [string, string];

package/dist/github-client.d.ts

@@ -605,8 +605,13 @@ export declare class GitHubClient {
     /** Every file path at a ref (branch, tag or sha), one API call. */
     listFiles(ref: string): Promise<string[]>;
     listPullRequests(state?: 'open' | 'closed' | 'all'): Promise<PullRequestSummary[]>;
-    /** Commit statuses and check runs of a commit, folded into one state. */
-    getChecks(sha: string): Promise<{
+    /**
+     * Commit statuses and check runs of a commit, folded into one state. `exploration`: the commit heads an exploration
+     * (explorations isGuardedExploration), so its guard check, failing by design, is left out (as review-gate summarizeCi).
+     */
+    getChecks(sha: string, opts?: {
+        exploration?: boolean | undefined;
+    }): Promise<{
         state: 'success' | 'failure' | 'pending' | 'none';
         checks: {
             name: string;